#!/usr/bin/env python
# MBTI 16人格测试软件
# -*- coding: utf-8 -*-

import sys
import random
import sqlite3
import datetime
import os
import matplotlib
matplotlib.use('Agg')  # 使用非交互式后端
import matplotlib.pyplot as plt

# 添加一个调试模式，用于直接测试雷达图
DEBUG_MODE = True  # 设置为True可以直接显示结果页面
from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QGridLayout,
    QLabel, QPushButton, QRadioButton, QGroupBox, QProgressBar,
    QMessageBox, QTableWidget, QTableWidgetItem, QHeaderView,
    QAbstractItemView, QDialog
)
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QFont, QIcon, QColor

# 确保中文显示正常
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题



# 定义MBTI 16人格类型信息
PERSONALITY_TYPES = {
    'ESTJ': {'name': '监督者', 'traits': ['注重实际', '逻辑思维', '组织能力强', '重视传统'],
             'career': ['管理者', '律师', '军事人员', '会计师'],
             'social': ['重视规则', '可靠', '喜欢明确的社交结构'],
             'learning': ['注重实用性', '喜欢结构化学习', '动手能力强']},
    'ESFJ': {'name': '供给者', 'traits': ['热情友好', '乐于助人', '重视和谐', '善于照顾他人'],
             'career': ['教师', '护士', '社会工作者', '客户服务'],
             'social': ['善于建立关系', '重视家庭', '喜欢参与社区活动'],
             'learning': ['通过互动学习', '重视实际应用', '喜欢合作学习']},
    'ENTJ': {'name': '指挥官', 'traits': ['自信果断', '战略性思维', '目标导向', '善于领导'],
             'career': ['企业高管', '项目经理', '律师', '政治家'],
             'social': ['直接', '有说服力', '喜欢智力挑战'],
             'learning': ['快速学习者', '喜欢理论和概念', '自主学习能力强']},
    'ENFJ': {'name': '教导者', 'traits': ['富有洞察力', '善于沟通', '理想主义', '重视他人成长'],
             'career': ['心理咨询师', '教师', '公共关系专家', '人力资源管理'],
             'social': ['善于倾听', '有同理心', '喜欢帮助他人'],
             'learning': ['通过讨论学习', '重视价值观', '喜欢与他人分享知识']},
    'ISTJ': {'name': '检查者', 'traits': ['严谨细致', 'responsibility', '务实可靠', '重视细节'],
             'career': ['会计', '审计师', '工程师', '档案管理员'],
             'social': ['保守', '可靠', '重视长期关系'],
             'learning': ['循序渐进', '注重准确性', '喜欢实践学习']},
    'ISFJ': {'name': '保护者', 'traits': ['温柔体贴', '富有同情心', '认真负责', '善于照顾他人'],
             'career': ['护士', '教师', '行政助理', '社会工作者'],
             'social': ['重视隐私', '忠诚', '喜欢稳定的社交圈'],
             'learning': ['耐心', '注重细节', '喜欢有明确目标的学习']},
    'INTJ': {'name': '建筑师', 'traits': ['富有洞察力', '逻辑思维', '独立思考', '追求卓越'],
             'career': ['科学家', '工程师', '战略顾问', '学术研究者'],
             'social': ['偏好深度交流', '重视隐私', '选择性社交'],
             'learning': ['自主学习', '喜欢理论研究', '注重系统化知识']},
    'INFJ': {'name': '咨询师', 'traits': ['理想主义', '直觉敏锐', '富有创造力', '重视精神层面'],
             'career': ['心理咨询师', '作家', '艺术家', '哲学家'],
             'social': ['深沉', '有同理心', '喜欢有意义的交流'],
             'learning': ['通过反思学习', '重视内在联系', '喜欢探索意义']},
    'ESTP': {'name': '创业者', 'traits': ['乐观开朗', '行动派', '适应性强', '善于解决问题'],
             'career': ['销售人员', '企业家', '运动员', '急救人员'],
             'social': ['外向', '喜欢冒险', '善于即兴发挥'],
             'learning': ['通过实践学习', '喜欢尝试新事物', '注重结果']},
    'ESFP': {'name': '表演者', 'traits': ['热情活泼', '善于表达', '喜欢享受生活', '重视当下'],
             'career': ['演员', '主持人', '营销人员', '旅游从业者'],
             'social': ['友好', '善于娱乐他人', '喜欢社交活动'],
             'learning': ['通过互动学习', '喜欢多样化', '注重趣味性']},
    'ENTP': {'name': '发明家', 'traits': ['好奇', '思维敏捷', '善于辩论', '喜欢挑战'],
             'career': ['科学家', '设计师', '市场营销', '律师'],
             'social': ['幽默', '喜欢头脑风暴', '善于打破常规'],
             'learning': ['快速学习', '喜欢探索新领域', '重视创新']},
    'ENFP': {'name': '奋斗者', 'traits': ['热情洋溢', '富有创造力', '理想主义', '善于社交'],
             'career': ['广告创意', '教育培训', '心理咨询', '创业'],
             'social': ['开放', '友好', '喜欢认识新朋友'],
             'learning': ['通过兴趣学习', '喜欢多样化', '重视个人成长']},
    'ISTP': {'name': '手艺者', 'traits': ['冷静理性', '动手能力强', '善于分析', '喜欢冒险'],
             'career': ['工程师', '技术人员', '侦探', '运动员'],
             'social': ['独立', '低调', '喜欢行动胜于言语'],
             'learning': ['通过实践学习', '喜欢解决实际问题', '注重效率']},
    'ISFP': {'name': '创作者', 'traits': ['敏感细腻', '富有艺术气质', '温和善良', '重视个人价值观'],
             'career': ['艺术家', '设计师', '兽医', '社会工作者'],
             'social': ['温和', '尊重他人', '喜欢和谐的环境'],
             'learning': ['通过体验学习', '喜欢个性化', '重视自我表达']},
    'INTP': {'name': '逻辑学家', 'traits': ['理性思维', '好奇', '善于分析', '追求知识'],
             'career': ['科学家', '程序员', '数学家', '哲学家'],
             'social': ['喜欢独处', '重视智力交流', '选择性社交'],
             'learning': ['自主学习', '喜欢探索原理', '重视逻辑']},
    'INFP': {'name': '治疗师', 'traits': ['理想主义', '敏感体贴', '富有同情心', '重视内在价值'],
             'career': ['心理咨询师', '作家', '教育工作者', '社会工作者'],
             'social': ['真诚', '重视深度关系', '喜欢有意义的交流'],
             'learning': ['通过兴趣学习', '重视个人价值观', '喜欢内省']}
}

# 示例题目数据
SAMPLE_QUESTIONS = [
    {
        'id': 1,
        'text': '当你在社交场合中，你更倾向于：',
        'options': [
            {'text': '主动与他人交流并享受其中', 'dimension': 'E'},
            {'text': '观察他人，在感到舒适时参与交流', 'dimension': 'I'},
            {'text': '视情况而定，有时主动有时被动', 'dimension': 'E'},
            {'text': '倾向于保持安静，倾听他人说话', 'dimension': 'I'}
        ]
    },
    {
        'id': 2,
        'text': '在做决定时，你通常更重视：',
        'options': [
            {'text': '逻辑分析和客观事实', 'dimension': 'T'},
            {'text': '个人价值观和他人感受', 'dimension': 'F'},
            {'text': '权衡利弊后做出决定', 'dimension': 'T'},
            {'text': '遵循内心的直觉和情感', 'dimension': 'F'}
        ]
    },
    {
        'id': 3,
        'text': '你更倾向于哪种工作方式？',
        'options': [
            {'text': '有明确的计划和截止日期', 'dimension': 'J'},
            {'text': '灵活安排，根据情况调整', 'dimension': 'P'},
            {'text': '提前规划，按部就班执行', 'dimension': 'J'},
            {'text': '喜欢即兴发挥，随机应变', 'dimension': 'P'}
        ]
    },
    {
        'id': 4,
        'text': '当你学习新事物时，你更喜欢：',
        'options': [
            {'text': '通过实际操作和体验', 'dimension': 'S'},
            {'text': '通过理论研究和思考', 'dimension': 'N'},
            {'text': '观察他人的做法并模仿', 'dimension': 'S'},
            {'text': '探索概念之间的联系', 'dimension': 'N'}
        ]
    },
    {
        'id': 5,
        'text': '在团队合作中，你更倾向于：',
        'options': [
            {'text': '积极参与讨论，表达自己的观点', 'dimension': 'E'},
            {'text': '认真倾听他人，在必要时发言', 'dimension': 'I'},
            {'text': '主动承担领导角色，组织大家', 'dimension': 'E'},
            {'text': '专注于自己的任务，默默贡献', 'dimension': 'I'}
        ]
    },
    {
        'id': 6,
        'text': '面对问题时，你更关注：',
        'options': [
            {'text': '当前的实际情况和细节', 'dimension': 'S'},
            {'text': '未来的可能性和潜在影响', 'dimension': 'N'},
            {'text': '具体的数据和事实', 'dimension': 'S'},
            {'text': '整体的趋势和模式', 'dimension': 'N'}
        ]
    },
    {
        'id': 7,
        'text': '在与人发生分歧时，你通常会：',
        'options': [
            {'text': '理性分析问题，寻找解决方案', 'dimension': 'T'},
            {'text': '考虑对方感受，寻求和谐', 'dimension': 'F'},
            {'text': '坚持自己的观点，据理力争', 'dimension': 'T'},
            {'text': '避免冲突，适当妥协', 'dimension': 'F'}
        ]
    },
    {
        'id': 8,
        'text': '对于生活，你更倾向于：',
        'options': [
            {'text': '有明确的目标和计划', 'dimension': 'J'},
            {'text': '随遇而安，享受当下', 'dimension': 'P'},
            {'text': '喜欢井井有条，按部就班', 'dimension': 'J'},
            {'text': '灵活多变，接受不确定性', 'dimension': 'P'}
        ]
    },
    {
        'id': 9,
        'text': '在社交活动后，你通常会感到：',
        'options': [
            {'text': '精力充沛，想要更多社交', 'dimension': 'E'},
            {'text': '需要独处来恢复精力', 'dimension': 'I'},
            {'text': '既满足又有些疲惫', 'dimension': 'E'},
            {'text': '希望尽快结束，回到安静环境', 'dimension': 'I'}
        ]
    },
    {
        'id': 10,
        'text': '你更相信哪种获取信息的方式？',
        'options': [
            {'text': '通过自己的观察和经验', 'dimension': 'S'},
            {'text': '通过直觉和灵感', 'dimension': 'N'},
            {'text': '通过可靠的资料和数据', 'dimension': 'S'},
            {'text': '通过联想和推理', 'dimension': 'N'}
        ]
    },
    {
        'id': 11,
        'text': '在评价他人时，你更重视：',
        'options': [
            {'text': '能力和成就', 'dimension': 'T'},
            {'text': '品格和价值观', 'dimension': 'F'},
            {'text': '理性和客观', 'dimension': 'T'},
            {'text': '善良和同理心', 'dimension': 'F'}
        ]
    },
    {
        'id': 12,
        'text': '对于时间管理，你更倾向于：',
        'options': [
            {'text': '严格按照计划执行', 'dimension': 'J'},
            {'text': '灵活安排，根据情况调整', 'dimension': 'P'},
            {'text': '提前完成任务，避免拖延', 'dimension': 'J'},
            {'text': '在压力下工作效率更高', 'dimension': 'P'}
        ]
    },
    {
        'id': 13,
        'text': '在学习或工作中，你更喜欢：',
        'options': [
            {'text': '与他人合作完成任务', 'dimension': 'E'},
            {'text': '独立工作，不受干扰', 'dimension': 'I'},
            {'text': '参与小组讨论和头脑风暴', 'dimension': 'E'},
            {'text': '专注于自己的领域深入研究', 'dimension': 'I'}
        ]
    },
    {
        'id': 14,
        'text': '面对新的想法或概念，你通常会：',
        'options': [
            {'text': '先验证其可行性和实用性', 'dimension': 'S'},
            {'text': '先探索其可能性和创新性', 'dimension': 'N'},
            {'text': '关注细节和具体应用', 'dimension': 'S'},
            {'text': '关注整体和长远影响', 'dimension': 'N'}
        ]
    },
    {
        'id': 15,
        'text': '在做决定时，你更依赖于：',
        'options': [
            {'text': '理性思考和逻辑分析', 'dimension': 'T'},
            {'text': '情感和直觉', 'dimension': 'F'},
            {'text': '客观事实和数据', 'dimension': 'T'},
            {'text': '个人价值观和信念', 'dimension': 'F'}
        ]
    },
    {
        'id': 16,
        'text': '对于未完成的任务，你通常会感到：',
        'options': [
            {'text': '焦虑，想要尽快完成', 'dimension': 'J'},
            {'text': '从容，相信能按时完成', 'dimension': 'P'},
            {'text': '有压力，会提前规划时间', 'dimension': 'J'},
            {'text': '灵活应对，不会过度担忧', 'dimension': 'P'}
        ]
    },
    {
        'id': 17,
        'text': '在社交场合中，你更倾向于扮演：',
        'options': [
            {'text': '活跃的中心人物', 'dimension': 'E'},
            {'text': '安静的观察者', 'dimension': 'I'},
            {'text': '积极的参与者', 'dimension': 'E'},
            {'text': '谨慎的聆听者', 'dimension': 'I'}
        ]
    },
    {
        'id': 18,
        'text': '你更重视哪种类型的信息？',
        'options': [
            {'text': '具体的、事实性的', 'dimension': 'S'},
            {'text': '抽象的、概念性的', 'dimension': 'N'},
            {'text': '实用的、可操作的', 'dimension': 'S'},
            {'text': '理论的、创新性的', 'dimension': 'N'}
        ]
    },
    {
        'id': 19,
        'text': '在解决问题时，你更倾向于：',
        'options': [
            {'text': '分析问题的各个部分', 'dimension': 'T'},
            {'text': '考虑问题的整体影响', 'dimension': 'F'},
            {'text': '寻找最优解', 'dimension': 'T'},
            {'text': '寻找让大家都满意的解决方案', 'dimension': 'F'}
        ]
    },
    {
        'id': 20,
        'text': '对于生活中的变化，你通常会：',
        'options': [
            {'text': '提前规划，做好准备', 'dimension': 'J'},
            {'text': '灵活适应，随机应变', 'dimension': 'P'},
            {'text': '有些不安，但会尝试接受', 'dimension': 'J'},
            {'text': '感到兴奋，认为是新的机会', 'dimension': 'P'}
        ]
    },
    {
        'id': 21,
        'text': '在与人交流时，你更倾向于：',
        'options': [
            {'text': '直接表达自己的想法', 'dimension': 'E'},
            {'text': '先倾听对方，再表达', 'dimension': 'I'},
            {'text': '积极参与讨论', 'dimension': 'E'},
            {'text': '深思熟虑后再发言', 'dimension': 'I'}
        ]
    },
    {
        'id': 22,
        'text': '你更相信哪种学习方式？',
        'options': [
            {'text': '通过实践和经验', 'dimension': 'S'},
            {'text': '通过理论和思考', 'dimension': 'N'},
            {'text': '通过具体的案例和示范', 'dimension': 'S'},
            {'text': '通过抽象的概念和模型', 'dimension': 'N'}
        ]
    },
    {
        'id': 23,
        'text': '在评价自己的行为时，你更重视：',
        'options': [
            {'text': '是否符合逻辑和理性', 'dimension': 'T'},
            {'text': '是否符合自己的价值观', 'dimension': 'F'},
            {'text': '是否达到了预期目标', 'dimension': 'T'},
            {'text': '是否让自己感到满足', 'dimension': 'F'}
        ]
    },
    {
        'id': 24,
        'text': '对于计划，你更倾向于：',
        'options': [
            {'text': '制定详细的计划并严格执行', 'dimension': 'J'},
            {'text': '制定大致的计划，灵活调整', 'dimension': 'P'},
            {'text': '喜欢提前安排好一切', 'dimension': 'J'},
            {'text': '更喜欢随机应变', 'dimension': 'P'}
        ]
    },
    {
        'id': 25,
        'text': '在团队中，你更关注：',
        'options': [
            {'text': '团队的目标和效率', 'dimension': 'T'},
            {'text': '团队成员的关系和感受', 'dimension': 'F'},
            {'text': '任务的完成情况', 'dimension': 'T'},
            {'text': '团队的和谐氛围', 'dimension': 'F'}
        ]
    }
]

class DatabaseManager:
    def __init__(self):
        # 获取用户AppData目录用于存储数据库，避免权限问题
        app_data_dir = os.path.join(os.environ.get('APPDATA', os.path.expanduser('~')), 'MBTI测试')
        os.makedirs(app_data_dir, exist_ok=True)
        self.db_path = os.path.join(app_data_dir, 'mbti_test_data.db')
        self.init_database()
        
    def init_database(self):
        # 初始化数据库，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                # 创建答题进度表
                cursor.execute('''
                CREATE TABLE IF NOT EXISTS test_progress (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id TEXT DEFAULT 'default_user',
                    current_question INTEGER,
                    answers TEXT,
                    start_time TEXT,
                    last_update_time TEXT
                )
                ''')
                
                # 创建测试记录表
                cursor.execute('''
                CREATE TABLE IF NOT EXISTS test_records (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id TEXT DEFAULT 'default_user',
                    test_time TEXT,
                    personality_type TEXT,
                    personality_name TEXT,
                    score_e INTEGER,
                    score_i INTEGER,
                    score_s INTEGER,
                    score_n INTEGER,
                    score_t INTEGER,
                    score_f INTEGER,
                    score_j INTEGER,
                    score_p INTEGER
                )
                ''')
                
                conn.commit()
        except sqlite3.Error as e:
            print(f"数据库初始化错误: {str(e)}")
        
    def save_progress(self, current_question, answers):
        # 保存答题进度，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                # 检查是否已有进度记录
                cursor.execute("SELECT id FROM test_progress WHERE user_id='default_user'")
                result = cursor.fetchone()
                
                current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                
                # 将answers字典转换为JSON字符串
                import json
                answers_json = json.dumps(answers)
                
                if result:
                    # 更新现有记录
                    cursor.execute(
                        "UPDATE test_progress SET current_question=?, answers=?, last_update_time=? WHERE id=?",
                        (current_question, answers_json, current_time, result[0])
                    )
                else:
                    # 创建新记录
                    cursor.execute(
                        "INSERT INTO test_progress (user_id, current_question, answers, start_time, last_update_time) VALUES (?, ?, ?, ?, ?)",
                        ('default_user', current_question, answers_json, current_time, current_time)
                    )
                
                conn.commit()
        except sqlite3.Error as e:
            print(f"保存进度错误: {str(e)}")
        
    def load_progress(self):
        # 加载答题进度，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                cursor.execute("SELECT current_question, answers FROM test_progress WHERE user_id='default_user'")
                result = cursor.fetchone()
                
                if result:
                    try:
                        # 安全地解析answers字符串为字典，使用json.loads替代eval以提高安全性
                        import json
                        answers = json.loads(result[1])
                        return {
                            'current_question': result[0],
                            'answers': answers
                        }
                    except:
                        # 如果解析失败，返回None
                        return None
                return None
        except sqlite3.Error as e:
            print(f"加载进度错误: {str(e)}")
            return None
        
    def clear_progress(self):
        # 清除答题进度，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                cursor.execute("DELETE FROM test_progress WHERE user_id='default_user'")
                
                conn.commit()
        except sqlite3.Error as e:
            print(f"清除进度错误: {str(e)}")
        
    def save_test_result(self, personality_type, scores):
        # 保存测试结果，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                personality_name = PERSONALITY_TYPES.get(personality_type, {}).get('name', '')
                
                cursor.execute(
                    '''INSERT INTO test_records (
                        user_id, test_time, personality_type, personality_name, 
                        score_e, score_i, score_s, score_n, 
                        score_t, score_f, score_j, score_p
                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
                    (
                        'default_user',
                        current_time,
                        personality_type,
                        personality_name,
                        scores.get('E', 0),
                        scores.get('I', 0),
                        scores.get('S', 0),
                        scores.get('N', 0),
                        scores.get('T', 0),
                        scores.get('F', 0),
                        scores.get('J', 0),
                        scores.get('P', 0)
                    )
                )
                
                conn.commit()
        except sqlite3.Error as e:
            print(f"保存测试结果错误: {str(e)}")
        
    def get_history_records(self):
        # 获取历史记录，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                cursor.execute(
                    "SELECT test_time, personality_type, personality_name FROM test_records WHERE user_id='default_user' ORDER BY test_time DESC"
                )
                
                records = cursor.fetchall()
                
                return [{
                    'time': record[0],
                    'type': record[1],
                    'name': record[2]
                } for record in records]
        except sqlite3.Error as e:
            print(f"获取历史记录错误: {str(e)}")
            return []
        
    def get_record_details(self, test_time):
        # 获取某次测试的详细结果，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                cursor.execute(
                    '''SELECT personality_type, personality_name, score_e, score_i, score_s, score_n, 
                       score_t, score_f, score_j, score_p FROM test_records 
                       WHERE user_id='default_user' AND test_time=?''',
                    (test_time,)
                )
                
                record = cursor.fetchone()
                
                if record:
                    return {
                        'personality_type': record[0],
                        'personality_name': record[1],
                        'scores': {
                            'E': record[2], 'I': record[3], 'S': record[4], 'N': record[5],
                            'T': record[6], 'F': record[7], 'J': record[8], 'P': record[9]
                        }
                    }
                return None
        except sqlite3.Error as e:
            print(f"获取记录详情错误: {str(e)}")
            return None
        
    def clean_old_records(self, days=365):
        # 清理过期记录，使用上下文管理器确保连接正确关闭
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                
                cutoff_date = (datetime.datetime.now() - datetime.timedelta(days=days)).strftime('%Y-%m-%d %H:%M:%S')
                
                cursor.execute("DELETE FROM test_records WHERE user_id='default_user' AND test_time < ?", (cutoff_date,))
                
                conn.commit()
        except sqlite3.Error as e:
            print(f"清理过期记录错误: {str(e)}")

class WelcomeWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.init_ui()
        
    def init_ui(self):
        # 设置窗口标题和尺寸
        self.setWindowTitle('MBTI 16人格测试')
        self.setGeometry(300, 200, 700, 500)
        
        # 设置窗口背景色
        self.setStyleSheet('background-color: #f8f9fa;')
        
        central_widget = QWidget()
        central_widget.setStyleSheet('background-color: #ffffff; border-radius: 15px;')
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(40, 40, 40, 40)
        self.setCentralWidget(central_widget)
        
        # 添加标题
        title_label = QLabel('MBTI 16人格测试')
        title_font = QFont()
        title_font.setFamily('微软雅黑')
        title_font.setPointSize(32)
        title_font.setBold(True)
        title_label.setFont(title_font)
        title_label.setAlignment(Qt.AlignCenter)
        title_label.setStyleSheet('color: #2c3e50;')
        main_layout.addWidget(title_label)
        main_layout.addSpacing(30)
        
        # 添加软件介绍
        intro_text = "MBTI人格测试是一种广泛使用的人格评估工具，\n" \
                     "帮助你了解自己的性格特点、优势和潜在发展方向。\n" \
                     "通过这个测试，你将获得属于自己的MBTI人格类型，\n" \
                     "以及个性化的解读和建议。"
        
        intro_label = QLabel(intro_text)
        intro_font = QFont()
        intro_font.setFamily('微软雅黑')
        intro_font.setPointSize(14)
        intro_label.setFont(intro_font)
        intro_label.setAlignment(Qt.AlignCenter)
        intro_label.setWordWrap(True)
        intro_label.setStyleSheet('color: #6c757d; line-height: 1.6;')
        main_layout.addWidget(intro_label)
        main_layout.addSpacing(40)
        
        # 添加开始测试按钮
        start_button = QPushButton('开始测试')
        start_button.setFont(QFont('微软雅黑', 16, QFont.Bold))
        start_button.setMinimumHeight(50)
        start_button.setStyleSheet('''
            QPushButton {
                background-color: #165DFF;
                color: white;
                border-radius: 25px;
                padding: 10px 30px;
            }
            QPushButton:hover {
                background-color: #1452e0;
            }
            QPushButton:pressed {
                background-color: #1249c1;
            }
        ''')
        start_button.clicked.connect(self.on_start_test)
        main_layout.addWidget(start_button, alignment=Qt.AlignCenter)
        main_layout.addSpacing(20)
        
        # 添加查看历史记录按钮
        history_button = QPushButton('查看历史记录')
        history_button.setFont(QFont('微软雅黑', 14))
        history_button.setMinimumHeight(40)
        history_button.setStyleSheet('''
            QPushButton {
                background-color: #F5F7FA;
                color: #495057;
                border: 1px solid #dee2e6;
                border-radius: 20px;
                padding: 8px 24px;
            }
            QPushButton:hover {
                background-color: #e9ecef;
            }
        ''')
        history_button.clicked.connect(self.on_view_history)
        main_layout.addWidget(history_button, alignment=Qt.AlignCenter)
        main_layout.addStretch()
        
        # 添加底部信息
        footer_label = QLabel('© 2023 MBTI人格测试软件 - 专业版')
        footer_label.setFont(QFont('微软雅黑', 10))
        footer_label.setAlignment(Qt.AlignCenter)
        footer_label.setStyleSheet('color: #adb5bd;')
        main_layout.addWidget(footer_label)
        
    def on_start_test(self):
        # 开始测试，跳转到测试窗口
        self.test_window = TestWindow()
        self.test_window.show()
        self.hide()
        
    def on_view_history(self):
        # 查看历史记录
        self.history_window = HistoryWindow()
        self.history_window.show()
        self.hide()

class TestWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.db_manager = DatabaseManager()
        self.questions = random.sample(SAMPLE_QUESTIONS, len(SAMPLE_QUESTIONS))  # 随机排序题目
        self.current_question_index = 0
        self.answers = {}
        self.selected_option = None
        
        # 尝试加载之前的进度
        progress = self.db_manager.load_progress()
        if progress:
            self.current_question_index = progress['current_question']
            self.answers = progress['answers']
        
        self.init_ui()
        
    def init_ui(self):
        # 设置窗口标题和尺寸
        self.setWindowTitle('MBTI人格测试 - 答题')
        self.setGeometry(300, 200, 800, 600)
        
        # 设置窗口背景色
        self.setStyleSheet('background-color: #f8f9fa;')
        
        # 创建主布局
        central_widget = QWidget()
        central_widget.setStyleSheet('background-color: #ffffff; border-radius: 15px;')
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(40, 30, 40, 30)
        self.setCentralWidget(central_widget)
        
        # 创建进度条
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, len(self.questions) - 1)
        self.progress_bar.setValue(self.current_question_index)
        self.progress_bar.setStyleSheet('''
            QProgressBar {
                height: 10px;
                border-radius: 5px;
                background-color: #e9ecef;
            }
            QProgressBar::chunk {
                background-color: #165DFF;
                border-radius: 5px;
            }
        ''')
        main_layout.addWidget(self.progress_bar)
        
        # 创建进度标签
        self.progress_label = QLabel(f'第 {self.current_question_index + 1} 题 / 共 {len(self.questions)} 题')
        self.progress_label.setFont(QFont('微软雅黑', 12))
        self.progress_label.setAlignment(Qt.AlignRight)
        self.progress_label.setStyleSheet('color: #6c757d;')
        main_layout.addWidget(self.progress_label)
        main_layout.addSpacing(20)
        
        # 创建题目标签
        self.question_label = QLabel()
        self.question_label.setFont(QFont('微软雅黑', 18, QFont.Bold))
        self.question_label.setWordWrap(True)
        self.question_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
        self.question_label.setMinimumHeight(120)
        self.question_label.setStyleSheet('color: #2c3e50;')
        main_layout.addWidget(self.question_label)
        main_layout.addSpacing(30)
        
        # 创建选项组
        self.options_group = QGroupBox()
        self.options_group.setStyleSheet('''
            QGroupBox {
                border: none;
                margin: 0;
                padding: 0;
            }
        ''')
        self.options_layout = QVBoxLayout(self.options_group)
        self.options_layout.setSpacing(15)
        self.option_buttons = []
        
        for i in range(4):
            option_button = QRadioButton()
            option_button.setFont(QFont('微软雅黑', 14))
            option_button.toggled.connect(lambda checked, idx=i: self.on_option_selected(idx))
            option_button.setStyleSheet('''
                QRadioButton {
                    color: #495057;
                    padding: 10px;
                    border-radius: 8px;
                    spacing: 10px;
                }
                QRadioButton:hover {
                    background-color: #f8f9fa;
                }
                QRadioButton::indicator {
                    width: 20px;
                    height: 20px;
                }
                QRadioButton::indicator::checked {
                    color: #165DFF;
                }
            ''')
            self.option_buttons.append(option_button)
            self.options_layout.addWidget(option_button)
        
        main_layout.addWidget(self.options_group)
        main_layout.addStretch()
        
        # 创建导航按钮
        nav_layout = QHBoxLayout()
        
        # 返回欢迎页按钮
        back_button = QPushButton('返回')
        back_button.setFont(QFont('微软雅黑', 12))
        back_button.setMinimumHeight(35)
        back_button.setStyleSheet('''
            QPushButton {
                background-color: #f8f9fa;
                color: #495057;
                border: 1px solid #dee2e6;
                border-radius: 20px;
                padding: 8px 20px;
            }
            QPushButton:hover {
                background-color: #e9ecef;
            }
        ''')
        back_button.clicked.connect(self.on_back)
        nav_layout.addWidget(back_button)
        nav_layout.addStretch()
        
        # 上一题按钮
        self.prev_button = QPushButton('上一题')
        self.prev_button.setFont(QFont('微软雅黑', 12))
        self.prev_button.setMinimumHeight(35)
        self.prev_button.setStyleSheet('''
            QPushButton {
                background-color: #f8f9fa;
                color: #495057;
                border: 1px solid #dee2e6;
                border-radius: 20px;
                padding: 8px 24px;
            }
            QPushButton:hover {
                background-color: #e9ecef;
            }
            QPushButton:disabled {
                background-color: #f8f9fa;
                color: #adb5bd;
                border-color: #dee2e6;
            }
        ''')
        self.prev_button.clicked.connect(self.on_prev)
        nav_layout.addWidget(self.prev_button)
        nav_layout.addSpacing(10)
        
        # 下一题按钮
        self.next_button = QPushButton('下一题')
        self.next_button.setFont(QFont('微软雅黑', 12))
        self.next_button.setMinimumHeight(35)
        self.next_button.setStyleSheet('''
            QPushButton {
                background-color: #165DFF;
                color: white;
                border-radius: 20px;
                padding: 8px 24px;
            }
            QPushButton:hover {
                background-color: #1452e0;
            }
        ''')
        self.next_button.clicked.connect(self.on_next)
        nav_layout.addWidget(self.next_button)
        
        # 提交按钮
        self.submit_button = QPushButton('提交')
        self.submit_button.setFont(QFont('微软雅黑', 12))
        self.submit_button.setMinimumHeight(35)
        self.submit_button.setStyleSheet('''
            QPushButton {
                background-color: #28a745;
                color: white;
                border-radius: 20px;
                padding: 8px 24px;
            }
            QPushButton:hover {
                background-color: #218838;
            }
            QPushButton:disabled {
                background-color: #f8f9fa;
                color: #adb5bd;
                border: 1px solid #dee2e6;
            }
        ''')
        self.submit_button.clicked.connect(self.on_submit)
        self.submit_button.setEnabled(False)  # 初始时禁用提交按钮
        nav_layout.addWidget(self.submit_button)
        
        main_layout.addLayout(nav_layout)
        
        # 加载当前题目
        self.load_current_question()
        
    def load_current_question(self):
        # 加载当前题目
        if 0 <= self.current_question_index < len(self.questions):
            question = self.questions[self.current_question_index]
            self.question_label.setText(question['text'])
            
            # 设置选项文本
            for i, option in enumerate(question['options']):
                self.option_buttons[i].setText(chr(65 + i) + '. ' + option['text'])
            
            # 重置选项选择状态
            for button in self.option_buttons:
                button.setChecked(False)
            
            # 检查是否已有答案
            question_id = str(question['id'])
            if question_id in self.answers:
                # 如果有已保存的答案，恢复选择状态
                selected_idx = self.answers[question_id]
                self.option_buttons[selected_idx].setChecked(True)
            else:
                # 如果没有已保存的答案，默认选择第一个选项（选项A）并保存
                self.option_buttons[0].setChecked(True)
                self.answers[question_id] = 0
                # 自动保存进度
                self.db_manager.save_progress(self.current_question_index, self.answers)
            
            # 更新进度显示
            self.progress_label.setText(f'第 {self.current_question_index + 1} 题 / 共 {len(self.questions)} 题')
            self.progress_bar.setValue(self.current_question_index)
            
            # 更新按钮状态
            self.prev_button.setEnabled(self.current_question_index > 0)
            self.next_button.setEnabled(True)
            self.submit_button.setEnabled(self.current_question_index == len(self.questions) - 1)
        
    def on_option_selected(self, option_index):
        # 处理选项选择
        if self.option_buttons[option_index].isChecked():
            question = self.questions[self.current_question_index]
            question_id = str(question['id'])
            self.answers[question_id] = option_index
            
            # 自动保存进度
            self.db_manager.save_progress(self.current_question_index, self.answers)
            
            # 如果是最后一题且所有题目都已回答，启用提交按钮
            if self.current_question_index == len(self.questions) - 1:
                self.submit_button.setEnabled(len(self.answers) == len(self.questions))
        
    def on_prev(self):
        # 上一题
        if self.current_question_index > 0:
            self.current_question_index -= 1
            self.load_current_question()
        
    def on_next(self):
        # 下一题
        if self.current_question_index < len(self.questions) - 1:
            self.current_question_index += 1
            self.load_current_question()
        
    def on_submit(self):
        # 提交测试
        # 检查所有题目是否都已回答
        all_answered = True
        unanswered_count = 0
        first_unanswered_index = -1
        
        # 遍历所有题目，找到未完成的题目
        for i, question in enumerate(self.questions):
            question_id = str(question['id'])
            if question_id not in self.answers:
                all_answered = False
                unanswered_count += 1
                # 记录第一个未完成的题目的索引
                if first_unanswered_index == -1:
                    first_unanswered_index = i
                
        if all_answered:
            # 计算得分
            scores = self.calculate_scores()
            
            # 清除答题进度
            self.db_manager.clear_progress()
            
            # 跳转到结果页面
            self.result_window = ResultWindow(scores)
            self.result_window.show()
            self.hide()
        else:
            # 自动跳转到第一个未完成的题目
            if first_unanswered_index != -1:
                self.current_question_index = first_unanswered_index
                self.load_current_question()
                
            # 显示更友好的提示信息，包含题号信息
            if unanswered_count == 1:
                message = f'您还有1题未完成，已自动为您跳转到该题，请完成后再提交！'
            else:
                message = f'您还有{unanswered_count}题未完成，已自动为您跳转到第一题未完成的题目，请继续完成！'
            QMessageBox.warning(self, '提示', message)
        
    def calculate_scores(self):
        # 计算各维度得分
        scores = {'E': 0, 'I': 0, 'S': 0, 'N': 0, 'T': 0, 'F': 0, 'J': 0, 'P': 0}
        
        for question in self.questions:
            question_id = str(question['id'])
            if question_id in self.answers:
                selected_idx = self.answers[question_id]
                dimension = question['options'][selected_idx]['dimension']
                scores[dimension] += 1
        
        # 确定人格类型
        e_i = 'E' if scores['E'] > scores['I'] else 'I'
        s_n = 'S' if scores['S'] > scores['N'] else 'N'
        t_f = 'T' if scores['T'] > scores['F'] else 'F'
        j_p = 'J' if scores['J'] > scores['P'] else 'P'
        
        personality_type = e_i + s_n + t_f + j_p
        
        return {
            'scores': scores,
            'personality_type': personality_type,
            'personality_name': PERSONALITY_TYPES.get(personality_type, {}).get('name', '')
        }
        
    def on_back(self):
        # 返回欢迎页
        self.welcome_window = WelcomeWindow()
        self.welcome_window.show()
        self.hide()
        
    def closeEvent(self, event):
        # 窗口关闭时保存进度
        self.db_manager.save_progress(self.current_question_index, self.answers)
        event.accept()

class ResultWindow(QMainWindow):
    def __init__(self, test_result):
        super().__init__()
        self.db_manager = DatabaseManager()
        self.test_result = test_result
        
        # 保存测试结果到数据库
        self.db_manager.save_test_result(
            self.test_result['personality_type'],
            self.test_result['scores']
        )
        
        self.init_ui()
        
    def init_ui(self):
        # 设置窗口标题和尺寸
        self.setWindowTitle('MBTI人格测试 - 结果')
        self.setGeometry(300, 200, 900, 700)
        
        # 设置窗口背景色
        self.setStyleSheet('background-color: #f8f9fa;')
        
        # 创建主布局
        central_widget = QWidget()
        central_widget.setStyleSheet('background-color: #ffffff; border-radius: 15px;')
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(40, 30, 40, 30)
        self.setCentralWidget(central_widget)
        
        # 添加人格类型标签
        personality_type = self.test_result['personality_type']
        personality_name = self.test_result['personality_name']
        
        type_label = QLabel(f'{personality_type} - {personality_name}')
        type_font = QFont('微软雅黑', 24, QFont.Bold)
        type_label.setFont(type_font)
        type_label.setAlignment(Qt.AlignCenter)
        type_label.setStyleSheet('color: #165DFF; margin-bottom: 10px;')
        main_layout.addWidget(type_label)
        
        # 添加人格类型描述
        type_desc = QLabel('您的MBTI人格类型解读结果')
        type_desc.setFont(QFont('微软雅黑', 14))
        type_desc.setAlignment(Qt.AlignCenter)
        type_desc.setStyleSheet('color: #6c757d;')
        main_layout.addWidget(type_desc)
        main_layout.addSpacing(30)
        
        # 创建内容区域布局
        content_layout = QHBoxLayout()
        
        # 左侧：维度得分和雷达图
        left_layout = QVBoxLayout()
        
        # 维度得分表
        score_group = QGroupBox('维度得分')
        score_group.setFont(QFont('微软雅黑', 14))
        score_group.setStyleSheet('''
            QGroupBox {
                border: 1px solid #dee2e6;
                border-radius: 8px;
                padding: 15px;
                margin-bottom: 10px;
            }
            QGroupBox::title {
                color: #495057;
                subcontrol-origin: margin;
                left: 15px;
            }
        ''')
        score_layout = QVBoxLayout(score_group)
        
        score_table = QTableWidget(4, 3)
        score_table.setHorizontalHeaderLabels(['维度', '得分', '倾向'])
        score_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        score_table.horizontalHeader().setStyleSheet('''
            QHeaderView::section {
                background-color: #f8f9fa;
                color: #495057;
                font-weight: bold;
                font-family: '微软雅黑';
                font-size: 12px;
                border: none;
                border-right: 1px solid #dee2e6;
            }
        ''')
        score_table.setStyleSheet('''
            QTableWidget {
                font-family: '微软雅黑';
                font-size: 12px;
                border: none;
            }
            QTableWidget::item {
                border: none;
                border-bottom: 1px solid #f8f9fa;
                padding: 10px;
            }
            QTableWidget::item:selected {
                background-color: #e3f2fd;
                color: #165DFF;
            }
        ''')
        
        scores = self.test_result['scores']
        dimensions = [
            ('外倾(E) / 内倾(I)', f"{scores['E']} / {scores['I']}", self.test_result['personality_type'][0]),
            ('感觉(S) / 直觉(N)', f"{scores['S']} / {scores['N']}", self.test_result['personality_type'][1]),
            ('思考(T) / 情感(F)', f"{scores['T']} / {scores['F']}", self.test_result['personality_type'][2]),
            ('判断(J) / 感知(P)', f"{scores['J']} / {scores['P']}", self.test_result['personality_type'][3])
        ]
        
        for row, (dim, score, pref) in enumerate(dimensions):
            dim_item = QTableWidgetItem(dim)
            dim_item.setTextAlignment(Qt.AlignCenter)
            score_item = QTableWidgetItem(score)
            score_item.setTextAlignment(Qt.AlignCenter)
            pref_item = QTableWidgetItem(pref)
            pref_item.setTextAlignment(Qt.AlignCenter)
            pref_item.setForeground(QColor('#165DFF'))
            
            score_table.setItem(row, 0, dim_item)
            score_table.setItem(row, 1, score_item)
            score_table.setItem(row, 2, pref_item)
        
        # 添加维度得分标题
        score_title = QLabel('维度得分')
        score_title.setFont(QFont('微软雅黑', 14, QFont.Bold))
        score_title.setStyleSheet('color: #495057; margin-bottom: 10px;')
        left_layout.addWidget(score_title)
        left_layout.addWidget(score_table)
        left_layout.addSpacing(20)

        # 添加人格类型详细描述卡片 - 填补原来雷达图的位置
        personality_desc_group = QGroupBox('人格特质详解')
        personality_desc_group.setFont(QFont('微软雅黑', 14))
        personality_desc_group.setStyleSheet('''
            QGroupBox {
                border: 1px solid #dee2e6;
                border-radius: 8px;
                padding: 15px;
                background-color: #f8f9ff;
            }
            QGroupBox::title {
                color: #495057;
                subcontrol-origin: margin;
                left: 15px;
            }
        ''')
        desc_layout = QVBoxLayout(personality_desc_group)

        # 人格类型的详细描述文本
        personality_desc_text = self.get_personality_description(personality_type)
        desc_label = QLabel(personality_desc_text)
        desc_label.setFont(QFont('微软雅黑', 12))
        desc_label.setWordWrap(True)
        desc_label.setStyleSheet('color: #495057; line-height: 1.6;')
        desc_layout.addWidget(desc_label)

        left_layout.addWidget(personality_desc_group)
        left_layout.addSpacing(10)

        # 添加适合的发展领域
        strengths_group = QGroupBox('适合的发展领域')
        strengths_group.setFont(QFont('微软雅黑', 14))
        strengths_group.setStyleSheet('''
            QGroupBox {
                border: 1px solid #dee2e6;
                border-radius: 8px;
                padding: 15px;
                background-color: #f0f9ff;
            }
            QGroupBox::title {
                color: #495057;
                subcontrol-origin: margin;
                left: 15px;
            }
        ''')
        strengths_layout = QVBoxLayout(strengths_group)

        strengths = self.get_personality_strengths(personality_type)
        for strength in strengths:
            strength_label = QLabel(f'• {strength}')
            strength_label.setFont(QFont('微软雅黑', 12))
            strength_label.setStyleSheet('color: #495057;')
            strengths_layout.addWidget(strength_label)

        left_layout.addWidget(strengths_group)
        left_layout.addSpacing(30)

        # 右侧：人格解读
        right_layout = QVBoxLayout()
        
        personality_data = PERSONALITY_TYPES.get(personality_type, {})
        
        # 核心特质
        traits_group = QGroupBox('核心特质')
        traits_layout = QVBoxLayout(traits_group)
        
        traits = personality_data.get('traits', ['暂无数据'])
        for trait in traits:
            trait_label = QLabel(f'• {trait}')
            trait_label.setFont(QFont('微软雅黑', 12))
            traits_layout.addWidget(trait_label)
        
        right_layout.addWidget(traits_group)
        right_layout.addSpacing(20)
        
        # 职业推荐
        career_group = QGroupBox('职业推荐')
        career_layout = QVBoxLayout(career_group)
        
        careers = personality_data.get('career', ['暂无数据'])
        for career in careers:
            career_label = QLabel(f'• {career}')
            career_label.setFont(QFont('微软雅黑', 12))
            career_layout.addWidget(career_label)
        
        right_layout.addWidget(career_group)
        right_layout.addSpacing(20)
        
        # 社交模式
        social_group = QGroupBox('社交模式')
        social_layout = QVBoxLayout(social_group)
        
        social = personality_data.get('social', ['暂无数据'])
        for item in social:
            social_label = QLabel(f'• {item}')
            social_label.setFont(QFont('微软雅黑', 12))
            social_layout.addWidget(social_label)
        
        right_layout.addWidget(social_group)
        right_layout.addSpacing(20)
        
        # 学习风格
        learning_group = QGroupBox('学习风格')
        learning_layout = QVBoxLayout(learning_group)
        
        learning = personality_data.get('learning', ['暂无数据'])
        for item in learning:
            learning_label = QLabel(f'• {item}')
            learning_label.setFont(QFont('微软雅黑', 12))
            learning_layout.addWidget(learning_label)
        
        right_layout.addWidget(learning_group)
        right_layout.addStretch()
        
        # 添加左右布局到内容布局
        content_layout.addLayout(left_layout, 1)
        content_layout.addSpacing(30)
        content_layout.addLayout(right_layout, 1)
        
        main_layout.addLayout(content_layout)
        main_layout.addSpacing(30)
        
        # 创建操作按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignCenter)
        
        # 重新测试按钮
        retest_button = QPushButton('重新测试')
        retest_button.setFont(QFont('微软雅黑', 14, QFont.Bold))
        retest_button.setMinimumHeight(45)
        retest_button.setStyleSheet('''
            QPushButton {
                background-color: #165DFF;
                color: white;
                border-radius: 25px;
                padding: 10px 30px;
                margin: 0 10px;
            }
            QPushButton:hover {
                background-color: #1452e0;
            }
        ''')
        retest_button.clicked.connect(self.on_retest)
        button_layout.addWidget(retest_button)
        
        # 查看历史记录按钮
        history_button = QPushButton('历史记录')
        history_button.setFont(QFont('微软雅黑', 14))
        history_button.setMinimumHeight(45)
        history_button.setStyleSheet('''
            QPushButton {
                background-color: #F5F7FA;
                color: #333;
                border: 1px solid #dee2e6;
                border-radius: 25px;
                padding: 10px 30px;
                margin: 0 10px;
            }
            QPushButton:hover {
                background-color: #e9ecef;
            }
        ''')
        history_button.clicked.connect(self.on_view_history)
        button_layout.addWidget(history_button)
        
        # 返回主页按钮
        home_button = QPushButton('返回主页')
        home_button.setFont(QFont('微软雅黑', 14))
        home_button.setMinimumHeight(45)
        home_button.setStyleSheet('''
            QPushButton {
                background-color: #F5F7FA;
                color: #333;
                border: 1px solid #dee2e6;
                border-radius: 25px;
                padding: 10px 30px;
                margin: 0 10px;
            }
            QPushButton:hover {
                background-color: #e9ecef;
            }
        ''')
        home_button.clicked.connect(self.on_back_home)
        button_layout.addWidget(home_button)
        
        main_layout.addLayout(button_layout)
        
        # 设置主窗口的大小策略，使其能够正确显示所有内容
        self.setMinimumSize(900, 700)
        

        
    def on_retest(self):
        # 重新测试
        self.test_window = TestWindow()
        self.test_window.show()
        self.hide()
        
    def on_view_history(self):
        # 查看历史记录
        self.history_window = HistoryWindow()
        self.history_window.show()
        self.hide()
        
    def get_personality_description(self, personality_type):
        """获取人格类型的详细描述"""
        descriptions = {
            'ESTJ': '''ESTJ型人格是传统和秩序的守护者，重视规则和结构。你们务实、可靠，善于组织和管理，
                通常在需要稳定性和执行力的环境中表现出色。重视家庭和传统价值观，
                是天生的领导者和组织者。''',
            'ESFJ': '''ESFJ型人格是热情友好的供给者，善于关心他人并创造和谐的环境。你们重视人际关系，
                善于理解他人的情感需求，乐于提供支持和帮助。通常在需要人际互动和照顾他人的角色中表现出色。''',
            'ENTJ': '''ENTJ型人格是天生的指挥官，具备战略性思维和领导能力。你们自信果断，
                善于制定计划并推动执行，在复杂情况下能够迅速做出决策。
                重视效率和结果，是出色的团队领导者和战略规划者。''',
            'ENFJ': '''ENFJ型人格是鼓舞人心的教导者，善于理解和激励他人。你们富有洞察力，
                能够看到他人的潜力并帮助其成长。重视价值观和道德准则，
                通常在需要沟通、指导和团队建设的角色中表现出色。''',
            'ISTJ': '''ISTJ型人格是严谨可靠的检查者，重视传统和秩序。你们务实、细致，
                善于遵循规则和程序，在需要精确和可靠性的工作中表现出色。
                重视责任和承诺，是值得信赖的团队成员。''',
            'ISFJ': '''ISFJ型人格是温柔体贴的保护者，善于照顾他人并创造和谐的环境。你们富有同情心，
                重视他人的感受和需求，乐于付出和支持。
                在需要耐心、细致和关怀的角色中表现出色。''',
            'INTJ': '''INTJ型人格是独立思考的建筑师，具备远见卓识和战略思维。你们理性、创新，
                善于分析复杂问题并提出解决方案。重视知识和效率，
                在需要深度思考和创新的领域表现出色。''',
            'INFJ': '''INFJ型人格是富有洞察力的咨询师，具备深刻的直觉和同理心。你们理想主义，
                重视内在价值和精神层面的成长，善于理解复杂的情感和关系。
                在需要深度思考和帮助他人的角色中表现出色。''',
            'ESTP': '''ESTP型人格是活力四射的创业者，善于应对挑战和把握机会。你们行动派，
                适应性强，在压力下能够保持冷静并解决问题。
                喜欢冒险和新体验，在需要灵活性和实际行动的环境中表现出色。''',
            'ESFP': '''ESFP型人格是热情活泼的表演者，善于享受生活并与人互动。你们外向、友好，
                善于表达和娱乐他人，在社交场合中充满魅力。
                在需要创造力和人际互动的领域表现出色。''',
            'ENTP': '''ENTP型人格是好奇机智的发明家，善于产生新想法和挑战现状。你们思维敏捷，
                喜欢辩论和探索可能性，在解决复杂问题时能够提出创新方案。
                在需要创造力和批判性思维的环境中表现出色。''',
            'ENFP': '''ENFP型人格是热情洋溢的奋斗者，充满理想主义和创造力。你们开放、好奇，
                善于发现新机会和可能性，在需要创新和灵感的领域表现出色。
                重视个人成长和有意义的人际关系。''',
            'ISTP': '''ISTP型人格是冷静理性的手艺者，善于分析和解决实际问题。你们务实、独立，
                喜欢亲身体验和动手实践，在需要技术能力和逻辑思维的领域表现出色。
                在压力下能够保持冷静并找到有效解决方案。''',
            'ISFP': '''ISFP型人格是敏感细腻的创作者，重视个人价值观和自我表达。你们温和、体贴，
                善于感受和理解他人的情感，在需要创造力和同理心的领域表现出色。
                重视和谐与平衡，不喜欢冲突和压力。''',
            'INTP': '''INTP型人格是理性好奇的逻辑学家，善于深入思考和分析复杂问题。你们独立、创新，
                重视知识和理性，在需要深度思考和理论探索的领域表现出色。
                喜欢挑战现有观念并寻找更优解决方案。''',
            'INFP': '''INFP型人格是理想主义的治疗师，重视内在价值和个人成长。你们敏感、体贴，
                善于理解他人的情感和需求，在需要同理心和创造力的领域表现出色。
                追求意义和真实，重视个人信念和价值观。'''
        }
        return descriptions.get(personality_type, '暂无详细描述信息')

    def get_personality_strengths(self, personality_type):
        """获取人格类型适合的发展领域"""
        strengths_map = {
            'ESTJ': ['管理和领导', '项目规划与执行', '财务和会计', '法律和法规遵从', '教育和培训'],
            'ESFJ': ['客户服务和支持', '医疗保健和护理', '教育和培训', '社会工作', '活动策划和组织'],
            'ENTJ': ['企业管理和领导', '战略规划', '法律', '政治和公共服务', '咨询和顾问'],
            'ENFJ': ['心理咨询和辅导', '教育和培训', '公共关系', '人力资源管理', '社会工作'],
            'ISTJ': ['会计和审计', '工程和技术', '法律和法规', '信息管理和档案', '质量控制'],
            'ISFJ': ['医疗保健和护理', '教育和培训', '行政和办公管理', '社会工作', '客户服务'],
            'INTJ': ['科学研究', '工程和技术', '战略咨询', '学术研究', '金融分析'],
            'INFJ': ['心理咨询和治疗', '写作和编辑', '艺术和设计', '哲学和宗教研究', '社会工作'],
            'ESTP': ['销售和市场营销', '创业和商业', '运动和娱乐', '急救和安全服务', '技术支持和维修'],
            'ESFP': ['表演艺术', '市场营销和广告', '旅游和酒店管理', '客户服务', '活动策划'],
            'ENTP': ['科学研究', '设计和创新', '市场营销和广告', '法律', '创业和商业'],
            'ENFP': ['广告和创意', '教育培训', '心理咨询', '创业', '公共关系'],
            'ISTP': ['工程和技术', '计算机编程', '侦探和调查', '运动和竞技', '军事和安全'],
            'ISFP': ['艺术和设计', '兽医和动物护理', '社会工作', '园艺和景观设计', '时尚和美容'],
            'INTP': ['科学研究', '计算机编程', '数学和统计', '哲学和逻辑学', '工程和技术'],
            'INFP': ['心理咨询和治疗', '写作和编辑', '教育和培训', '社会工作', '艺术和设计']
        }
        return strengths_map.get(personality_type, ['暂无推荐领域'])

    def on_back_home(self):
        # 返回主页
        self.welcome_window = WelcomeWindow()
        self.welcome_window.show()
        self.hide()

class HistoryWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.db_manager = DatabaseManager()
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle('历史记录')
        self.setGeometry(100, 100, 900, 600)
        self.setStyleSheet('background-color: #f0f2f5;')

        # 创建中央部件
        central_widget = QWidget()
        central_widget.setStyleSheet('background-color: white; border-radius: 10px;')
        self.setCentralWidget(central_widget)

        # 创建主布局
        main_layout = QVBoxLayout(central_widget)
        main_layout.setContentsMargins(20, 20, 20, 20)
        main_layout.setSpacing(20)

        # 创建标题标签
        title_label = QLabel('测试历史记录')
        title_label.setStyleSheet('font-size: 24px; font-weight: bold; color: #333; margin-bottom: 10px;')
        main_layout.addWidget(title_label, alignment=Qt.AlignCenter)

        # 创建表格
        self.table_widget = QTableWidget()
        self.table_widget.setColumnCount(4)
        self.table_widget.setHorizontalHeaderLabels(['测试日期', '人格类型', '详细结果', '操作'])
        
        # 设置表格样式
        self.table_widget.setStyleSheet('''
            QTableWidget {
                background-color: #f9f9f9;
                border: 1px solid #e0e0e0;
                border-radius: 8px;
                gridline-color: #e0e0e0;
            }
            QHeaderView::section {
                background-color: #f0f0f0;
                padding: 10px;
                font-weight: bold;
                color: #333;
                border: 1px solid #e0e0e0;
            }
            QTableWidgetItem {
                padding: 10px;
                color: #333;
            }
            QTableWidgetItem:selected {
                background-color: #e3f2fd;
                color: #1976d2;
            }
        ''')

        # 设置列宽
        self.table_widget.setColumnWidth(0, 200)
        self.table_widget.setColumnWidth(1, 100)
        self.table_widget.setColumnWidth(2, 300)
        self.table_widget.horizontalHeader().setSectionResizeMode(3, QHeaderView.Stretch)
        self.table_widget.setAlternatingRowColors(True)
        self.table_widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.table_widget.setSelectionBehavior(QAbstractItemView.SelectRows)
        
        main_layout.addWidget(self.table_widget)

        # 创建底部按钮布局
        button_layout = QHBoxLayout()
        button_layout.setSpacing(15)

        # 创建清理数据按钮
        self.clean_button = QPushButton('清理过期数据')
        self.clean_button.setStyleSheet('''
            QPushButton {
                background-color: #ffebee;
                color: #c62828;
                border: 1px solid #ffcdd2;
                border-radius: 8px;
                padding: 10px 20px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #ffcdd2;
            }
        ''')
        self.clean_button.clicked.connect(self.on_clean_data)
        button_layout.addWidget(self.clean_button)

        button_layout.addStretch()

        # 创建返回按钮
        self.back_button = QPushButton('返回主页')
        self.back_button.setStyleSheet('''
            QPushButton {
                background-color: #F5F7FA;
                color: #333;
                border: 1px solid #ddd;
                border-radius: 8px;
                padding: 10px 20px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #e0e5ec;
            }
        ''')
        self.back_button.clicked.connect(self.on_back_home)
        button_layout.addWidget(self.back_button)

        main_layout.addLayout(button_layout)

        # 加载历史记录
        self.load_history_records()

    def load_history_records(self):
        # 清空表格
        self.table_widget.setRowCount(0)
        
        # 从数据库加载历史记录
        records = self.db_manager.get_history_records()
        
        if not records:
            # 如果没有历史记录，显示提示信息
            no_data_label = QLabel('暂无历史记录')
            no_data_label.setAlignment(Qt.AlignCenter)
            no_data_label.setStyleSheet('color: #999; font-style: italic;')
            self.table_widget.setCellWidget(0, 0, no_data_label)
            self.table_widget.setSpan(0, 0, 1, 4)
            return
        
        # 添加记录到表格
        for i, record in enumerate(records):
            self.table_widget.insertRow(i)
            
            # 日期列
            date_item = QTableWidgetItem(record['time'])
            date_item.setTextAlignment(Qt.AlignCenter)
            self.table_widget.setItem(i, 0, date_item)
            
            # 人格类型列
            type_item = QTableWidgetItem(record['type'])
            type_item.setTextAlignment(Qt.AlignCenter)
            self.table_widget.setItem(i, 1, type_item)
            
            # 详细结果列
            details = f"{record['name']}"
            details_item = QTableWidgetItem(details)
            self.table_widget.setItem(i, 2, details_item)
            
            # 操作列 - 查看详情按钮
            view_button = QPushButton('查看详情')
            view_button.setStyleSheet('''
                QPushButton {
                    background-color: #e3f2fd;
                    color: #1976d2;
                    border: 1px solid #90caf9;
                    border-radius: 6px;
                    padding: 6px 12px;
                    font-weight: bold;
                }
                QPushButton:hover {
                    background-color: #bbdefb;
                }
            ''')
            view_button.setFixedWidth(100)
            view_button.clicked.connect(lambda checked, record_id=record['time']: self.on_view_detail(record_id))
            
            button_widget = QWidget()
            button_layout = QHBoxLayout(button_widget)
            button_layout.setAlignment(Qt.AlignCenter)
            button_layout.addWidget(view_button)
            button_layout.setContentsMargins(5, 5, 5, 5)
            
            self.table_widget.setCellWidget(i, 3, button_widget)

    def on_view_detail(self, record_id):
        # 获取记录详情
        record = self.db_manager.get_record_details(record_id)
        if not record:
            QMessageBox.warning(self, '警告', '无法获取记录详情')
            return
        
        # 创建详情对话框
        dialog = QDialog(self)
        dialog.setWindowTitle('测试详情')
        dialog.setGeometry(200, 200, 600, 500)
        dialog.setStyleSheet('background-color: white;')
        
        # 创建布局
        layout = QVBoxLayout(dialog)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(15)
        
        # 添加基本信息
        info_layout = QGridLayout()
        
        info_layout.addWidget(QLabel('测试日期:'), 0, 0)
        info_layout.addWidget(QLabel(record_id), 0, 1)
        
        info_layout.addWidget(QLabel('人格类型:'), 1, 0)
        personality_label = QLabel(record['personality_type'])
        personality_label.setStyleSheet('font-weight: bold; color: #1976d2;')
        info_layout.addWidget(personality_label, 1, 1)
        
        info_layout.addWidget(QLabel('人格名称:'), 2, 0)
        info_layout.addWidget(QLabel(record['personality_name']), 2, 1)
        
        layout.addLayout(info_layout)
        
        # 添加维度得分
        scores_group = QGroupBox('维度得分')
        scores_group.setStyleSheet('QGroupBox { font-weight: bold; border: 1px solid #ddd; border-radius: 8px; margin-top: 10px; padding: 10px; }')
        scores_layout = QGridLayout(scores_group)
        
        dimensions = ['E', 'I', 'S', 'N', 'T', 'F', 'J', 'P']
        row = 0
        col = 0
        
        for dim in dimensions:
            scores_layout.addWidget(QLabel(f'{dim}:'), row, col*2)
            score_label = QLabel(str(record['scores'][dim]))
            score_label.setStyleSheet('color: #333;')
            scores_layout.addWidget(score_label, row, col*2 + 1)
            
            col += 1
            if col >= 4:
                col = 0
                row += 1
        
        layout.addWidget(scores_group)
        
        # 添加关闭按钮
        close_button = QPushButton('关闭')
        close_button.setStyleSheet('''
            QPushButton {
                background-color: #F5F7FA;
                color: #333;
                border: 1px solid #ddd;
                border-radius: 8px;
                padding: 10px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #e0e5ec;
            }
        ''')
        close_button.clicked.connect(dialog.accept)
        layout.addWidget(close_button, alignment=Qt.AlignCenter)
        
        dialog.exec_()

    def on_clean_data(self):
        # 确认对话框
        reply = QMessageBox.question(
            self, '确认清理', 
            '确定要清理30天前的历史数据吗？此操作不可恢复。',
            QMessageBox.Yes | QMessageBox.No, QMessageBox.No
        )
        
        if reply == QMessageBox.Yes:
            # 清理过期数据
            self.db_manager.clean_old_records()
            # 重新加载历史记录
            self.load_history_records()
            QMessageBox.information(self, '成功', '过期数据已清理')

    def on_back_home(self):
        # 返回欢迎页面
        self.welcome_window = WelcomeWindow()
        self.welcome_window.show()
        self.close()

# 确保导入QtGui模块用于颜色设置
from PyQt5 import QtGui

def main():
    # 创建应用程序实例
    app = QApplication(sys.argv)
    
    # 设置应用程序样式
    app.setStyle('Fusion')
    
    if DEBUG_MODE:
        # 在调试模式下，直接显示结果页面和雷达图
        # 创建模拟的测试结果数据
        test_result = {
            'scores': {
                'E': 7, 'I': 3,
                'S': 6, 'N': 4,
                'T': 5, 'F': 5,
                'J': 8, 'P': 2
            },
            'personality_type': 'ENTJ',
            'personality_name': '指挥官'
        }
        
        # 创建并显示结果窗口
        result_window = ResultWindow(test_result)
        result_window.show()
    else:
        # 正常模式下，显示欢迎窗口
        welcome_window = WelcomeWindow()
        welcome_window.show()
    
    # 运行应用程序主循环
    sys.exit(app.exec_())

if __name__ == '__main__':
    main()
